home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / seyon / SeString.c < prev    next >
C/C++ Source or Header  |  1995-05-03  |  5KB  |  294 lines
  1.  
  2. /*
  3.  * This file is part of the Seyon, Copyright (c) 1992-1993 by Muhammad M.
  4.  * Saggaf. All rights reserved.
  5.  *
  6.  * See the file COPYING (1-COPYING) or the manual page seyon(1) for a full
  7.  * statement of rights and permissions for this program.
  8.  */
  9.  
  10. #include <ctype.h>
  11.  
  12. #include "config.h"
  13. #include "SeDecl.h"
  14.  
  15. char           *str_strip_lead_end_space(),
  16.                *str_strip_lead_space(),
  17.                *str_strip_end_space();
  18.  
  19. /*
  20.  * string routines
  21.  */
  22.  
  23. char
  24. itoa(num)
  25.      int             num;
  26. {
  27.   char            buf[TIN_BUF];
  28.  
  29.   sprintf(buf, "%d", num);
  30.   return buf[0];
  31. }
  32.  
  33. /*
  34.  * replace unwanted characters with something else
  35.  */
  36.  
  37. char           *
  38. str_filter(str, unwanted, replacement)
  39.      char           *str,
  40.                     *unwanted;
  41.      char            replacement;
  42. {
  43.   int             i,
  44.                   j;
  45.  
  46.   for (i = 0; str[i]; i++)
  47.     for (j = 0; unwanted[j]; j++)
  48.       if (str[i] == unwanted[j])
  49.     str[i] = replacement;
  50.  
  51.   return str;
  52. }
  53.  
  54. /*
  55.  * strip spaces from both ends of a string
  56.  */
  57.  
  58. char           *
  59. str_strip_lead_end_space(str)
  60.      char           *str;
  61. {
  62.   return str_strip_lead_space(str_strip_end_space(str));
  63. }
  64.  
  65. /*
  66.  * strip spaces from the beginning a string
  67.  */
  68.  
  69. char           *
  70. str_strip_lead_space(str)
  71.      char           *str;
  72. {
  73.   int             i;
  74.  
  75.   for (i = 0; isspace(str[i]); i++);
  76.   return str + i;
  77. }
  78.  
  79. /*
  80.  * strip spaces from the end a string
  81.  */
  82.  
  83. char           *
  84. str_strip_end_space(str)
  85.      char           *str;
  86. {
  87.   int             i;
  88.  
  89.   for (i = strlen(str) - 1; i>0 && isspace(str[i]); i--);
  90.   str[++i] = '\0';
  91.  
  92.   return str;
  93. }
  94.  
  95. char           *
  96. str_stripspc_copy(dest, source)
  97.      char           *dest,
  98.                     *source;
  99. {
  100.   char            buffer[REG_BUF],
  101.                  *bufptr;
  102.  
  103.   strcpy(buffer, source);
  104.   bufptr = str_strip_lead_end_space(buffer);
  105.   return strcpy(dest, bufptr);
  106. }
  107.  
  108.  
  109. char           *
  110. str_strip_end_char(str)
  111.      char           *str;
  112. {
  113.   int             length;
  114.  
  115.   length = strlen(str);
  116.   if(length>0) str[length - 1] = '\0';
  117.  
  118.   return str;
  119. }
  120.  
  121. char*
  122. StripSpace(str)
  123.      char *str;
  124. {
  125.   static char strBuf[LRG_BUF];
  126.   
  127.   str_stripspc_copy(strBuf, str);
  128.   return strBuf;
  129. }
  130.  
  131. char*
  132. FmtString(fmt, a, b, c)
  133.      char *fmt, *a, *b, *c;
  134. {
  135.   static char strBuf[LRG_BUF];
  136.  
  137.   sprintf(strBuf, fmt, a, b, c);
  138.   return strBuf;
  139. }
  140.  
  141. /*
  142.  * find first occurance of str2 in str1 and return a pointer to it
  143.  */
  144.  
  145. #if !HAVE_STRSTR
  146. char           *
  147. strstr(str1, str2)
  148.      char           *str1,
  149.                     *str2;
  150. {
  151.   char           *Sptr,
  152.                  *Tptr;
  153.   int             len = strlen(str1) - strlen(str2) + 1;
  154.  
  155.   if (*str2)
  156.     for (; len > 0; len--, str1++) {
  157.       if (*str1 != *str2)
  158.         continue;
  159.       
  160.       for (Sptr = str1, Tptr = str2; *Tptr != '\0'; Sptr++, Tptr++)
  161.         if (*Sptr != *Tptr)
  162.           break;
  163.       
  164.       if (*Tptr == '\0')
  165.         return str1;
  166.     }
  167.  
  168.   return NULL;
  169. }
  170.  
  171. #endif
  172.  
  173. char           *
  174. strsqtok(str)
  175.      char           *str;
  176. {
  177.   char           *line,
  178.                  *wrd;
  179.   static char    *saved_ptr;
  180.  
  181.   if (str == NULL)
  182.     line = saved_ptr;
  183.   else
  184.     line = str;
  185.  
  186.   while (isspace(*line) && *line)
  187.     line++;
  188.  
  189.   if (*line == '\0')
  190.     return NULL;
  191.   else if (*line == '\"')
  192.     for (wrd = ++line; *line != '\"' && *line; line++);
  193.   else
  194.     for (wrd = line; !isspace(*line) && *line; line++);
  195.  
  196.   if (*line == '\0')
  197.     saved_ptr = line;
  198.   else
  199.     saved_ptr = line + 1;
  200.  
  201.   *line = '\0';
  202.   return wrd;
  203. }
  204.  
  205. /*
  206.  * return the first word of a string and set the start of the string
  207.  * to point to the next one
  208.  */
  209.  
  210. /*
  211.  * WARNING: words returned by this routine are not null-termnated
  212.  */
  213.  
  214. char           *
  215. str_parse(buf)
  216.      char          **buf;
  217. {
  218.   char           *line,
  219.                  *wrd;
  220.  
  221.   /*
  222.    * Remember: *buf is a pointer to the string, **buf is a character
  223.    * in the string
  224.    */
  225.  
  226.   line = *buf;
  227.  
  228.   while (isspace(*line) && *line)
  229.     line++;
  230.  
  231.   if (!(*line))
  232.     return NULL;
  233.   else if (*line == '\"') {
  234.     for (wrd = ++line; *line != '\"' && *line; line++);
  235.     *line = '\0';
  236.     line++;
  237.   }
  238.   else
  239.     for (wrd = line; !isspace(*line) && *line; line++);
  240.  
  241.   *buf = line;
  242.   return wrd;
  243. }
  244.  
  245. /*
  246.  * this routine is not currently used, and I'm not if it works
  247.  */
  248.  
  249. char           *
  250. get_word(str, word)
  251.      char           *str,
  252.                     *word;
  253. {
  254.   char           *wrd,
  255.                   c;
  256.  
  257.   while (isspace(*str) && *str)
  258.     str++;
  259.  
  260.   if (!(*str))
  261.     word[0] = '\0';
  262.  
  263.   else if (*str == '\"') {
  264.     for (wrd = ++str; *str != '\"' && *str; str++);
  265.     *str = '\0';
  266.     strcpy(word, wrd);
  267.     *str = '\"';
  268.     str++;
  269.   }
  270.  
  271.   else {
  272.     for (wrd = str; !isspace(*str) && *str; str++);
  273.     c = *str;
  274.     *str = '\0';
  275.     strcpy(word, wrd);
  276.     *str = c;
  277.   }
  278.  
  279.   return str;
  280. }
  281.  
  282. #if !HAVE_STRERROR
  283.  
  284. char *
  285. strerror(err)
  286.      int err;
  287. {
  288.   extern char *sys_errlist[];
  289.  
  290.   return sys_errlist[err];
  291. }
  292.  
  293. #endif
  294.